home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / hity wydania / Ubuntu 9.10 PL / karmelkowy-koliberek-9.10-netbook-remix-PL.iso / casper / filesystem.squashfs / usr / include / linux / fuse.h < prev    next >
C/C++ Source or Header  |  2009-10-16  |  10KB  |  544 lines
  1. /*
  2.     FUSE: Filesystem in Userspace
  3.     Copyright (C) 2001-2008  Miklos Szeredi <miklos@szeredi.hu>
  4.  
  5.     This program can be distributed under the terms of the GNU GPL.
  6.     See the file COPYING.
  7. */
  8.  
  9. /*
  10.  * This file defines the kernel interface of FUSE
  11.  *
  12.  * Protocol changelog:
  13.  *
  14.  * 7.9:
  15.  *  - new fuse_getattr_in input argument of GETATTR
  16.  *  - add lk_flags in fuse_lk_in
  17.  *  - add lock_owner field to fuse_setattr_in, fuse_read_in and fuse_write_in
  18.  *  - add blksize field to fuse_attr
  19.  *  - add file flags field to fuse_read_in and fuse_write_in
  20.  *
  21.  * 7.10
  22.  *  - add nonseekable open flag
  23.  *
  24.  * 7.11
  25.  *  - add IOCTL message
  26.  *  - add unsolicited notification support
  27.  *  - add POLL message and NOTIFY_POLL notification
  28.  *
  29.  * 7.12
  30.  *  - add umask flag to input argument of open, mknod and mkdir
  31.  *  - add notification messages for invalidation of inodes and
  32.  *    directory entries
  33.  */
  34.  
  35. #ifndef _LINUX_FUSE_H
  36. #define _LINUX_FUSE_H
  37.  
  38. #include <linux/types.h>
  39.  
  40. /** Version number of this interface */
  41. #define FUSE_KERNEL_VERSION 7
  42.  
  43. /** Minor version number of this interface */
  44. #define FUSE_KERNEL_MINOR_VERSION 12
  45.  
  46. /** The node ID of the root inode */
  47. #define FUSE_ROOT_ID 1
  48.  
  49. /* Make sure all structures are padded to 64bit boundary, so 32bit
  50.    userspace works under 64bit kernels */
  51.  
  52. struct fuse_attr {
  53.     __u64    ino;
  54.     __u64    size;
  55.     __u64    blocks;
  56.     __u64    atime;
  57.     __u64    mtime;
  58.     __u64    ctime;
  59.     __u32    atimensec;
  60.     __u32    mtimensec;
  61.     __u32    ctimensec;
  62.     __u32    mode;
  63.     __u32    nlink;
  64.     __u32    uid;
  65.     __u32    gid;
  66.     __u32    rdev;
  67.     __u32    blksize;
  68.     __u32    padding;
  69. };
  70.  
  71. struct fuse_kstatfs {
  72.     __u64    blocks;
  73.     __u64    bfree;
  74.     __u64    bavail;
  75.     __u64    files;
  76.     __u64    ffree;
  77.     __u32    bsize;
  78.     __u32    namelen;
  79.     __u32    frsize;
  80.     __u32    padding;
  81.     __u32    spare[6];
  82. };
  83.  
  84. struct fuse_file_lock {
  85.     __u64    start;
  86.     __u64    end;
  87.     __u32    type;
  88.     __u32    pid; /* tgid */
  89. };
  90.  
  91. /**
  92.  * Bitmasks for fuse_setattr_in.valid
  93.  */
  94. #define FATTR_MODE    (1 << 0)
  95. #define FATTR_UID    (1 << 1)
  96. #define FATTR_GID    (1 << 2)
  97. #define FATTR_SIZE    (1 << 3)
  98. #define FATTR_ATIME    (1 << 4)
  99. #define FATTR_MTIME    (1 << 5)
  100. #define FATTR_FH    (1 << 6)
  101. #define FATTR_ATIME_NOW    (1 << 7)
  102. #define FATTR_MTIME_NOW    (1 << 8)
  103. #define FATTR_LOCKOWNER    (1 << 9)
  104.  
  105. /**
  106.  * Flags returned by the OPEN request
  107.  *
  108.  * FOPEN_DIRECT_IO: bypass page cache for this open file
  109.  * FOPEN_KEEP_CACHE: don't invalidate the data cache on open
  110.  * FOPEN_NONSEEKABLE: the file is not seekable
  111.  */
  112. #define FOPEN_DIRECT_IO        (1 << 0)
  113. #define FOPEN_KEEP_CACHE    (1 << 1)
  114. #define FOPEN_NONSEEKABLE    (1 << 2)
  115.  
  116. /**
  117.  * INIT request/reply flags
  118.  *
  119.  * FUSE_EXPORT_SUPPORT: filesystem handles lookups of "." and ".."
  120.  * FUSE_DONT_MASK: don't apply umask to file mode on create operations
  121.  */
  122. #define FUSE_ASYNC_READ        (1 << 0)
  123. #define FUSE_POSIX_LOCKS    (1 << 1)
  124. #define FUSE_FILE_OPS        (1 << 2)
  125. #define FUSE_ATOMIC_O_TRUNC    (1 << 3)
  126. #define FUSE_EXPORT_SUPPORT    (1 << 4)
  127. #define FUSE_BIG_WRITES        (1 << 5)
  128. #define FUSE_DONT_MASK        (1 << 6)
  129.  
  130. /**
  131.  * CUSE INIT request/reply flags
  132.  *
  133.  * CUSE_UNRESTRICTED_IOCTL:  use unrestricted ioctl
  134.  */
  135. #define CUSE_UNRESTRICTED_IOCTL    (1 << 0)
  136.  
  137. /**
  138.  * Release flags
  139.  */
  140. #define FUSE_RELEASE_FLUSH    (1 << 0)
  141.  
  142. /**
  143.  * Getattr flags
  144.  */
  145. #define FUSE_GETATTR_FH        (1 << 0)
  146.  
  147. /**
  148.  * Lock flags
  149.  */
  150. #define FUSE_LK_FLOCK        (1 << 0)
  151.  
  152. /**
  153.  * WRITE flags
  154.  *
  155.  * FUSE_WRITE_CACHE: delayed write from page cache, file handle is guessed
  156.  * FUSE_WRITE_LOCKOWNER: lock_owner field is valid
  157.  */
  158. #define FUSE_WRITE_CACHE    (1 << 0)
  159. #define FUSE_WRITE_LOCKOWNER    (1 << 1)
  160.  
  161. /**
  162.  * Read flags
  163.  */
  164. #define FUSE_READ_LOCKOWNER    (1 << 1)
  165.  
  166. /**
  167.  * Ioctl flags
  168.  *
  169.  * FUSE_IOCTL_COMPAT: 32bit compat ioctl on 64bit machine
  170.  * FUSE_IOCTL_UNRESTRICTED: not restricted to well-formed ioctls, retry allowed
  171.  * FUSE_IOCTL_RETRY: retry with new iovecs
  172.  *
  173.  * FUSE_IOCTL_MAX_IOV: maximum of in_iovecs + out_iovecs
  174.  */
  175. #define FUSE_IOCTL_COMPAT    (1 << 0)
  176. #define FUSE_IOCTL_UNRESTRICTED    (1 << 1)
  177. #define FUSE_IOCTL_RETRY    (1 << 2)
  178.  
  179. #define FUSE_IOCTL_MAX_IOV    256
  180.  
  181. /**
  182.  * Poll flags
  183.  *
  184.  * FUSE_POLL_SCHEDULE_NOTIFY: request poll notify
  185.  */
  186. #define FUSE_POLL_SCHEDULE_NOTIFY (1 << 0)
  187.  
  188. enum fuse_opcode {
  189.     FUSE_LOOKUP       = 1,
  190.     FUSE_FORGET       = 2,  /* no reply */
  191.     FUSE_GETATTR       = 3,
  192.     FUSE_SETATTR       = 4,
  193.     FUSE_READLINK       = 5,
  194.     FUSE_SYMLINK       = 6,
  195.     FUSE_MKNOD       = 8,
  196.     FUSE_MKDIR       = 9,
  197.     FUSE_UNLINK       = 10,
  198.     FUSE_RMDIR       = 11,
  199.     FUSE_RENAME       = 12,
  200.     FUSE_LINK       = 13,
  201.     FUSE_OPEN       = 14,
  202.     FUSE_READ       = 15,
  203.     FUSE_WRITE       = 16,
  204.     FUSE_STATFS       = 17,
  205.     FUSE_RELEASE       = 18,
  206.     FUSE_FSYNC         = 20,
  207.     FUSE_SETXATTR      = 21,
  208.     FUSE_GETXATTR      = 22,
  209.     FUSE_LISTXATTR     = 23,
  210.     FUSE_REMOVEXATTR   = 24,
  211.     FUSE_FLUSH         = 25,
  212.     FUSE_INIT          = 26,
  213.     FUSE_OPENDIR       = 27,
  214.     FUSE_READDIR       = 28,
  215.     FUSE_RELEASEDIR    = 29,
  216.     FUSE_FSYNCDIR      = 30,
  217.     FUSE_GETLK         = 31,
  218.     FUSE_SETLK         = 32,
  219.     FUSE_SETLKW        = 33,
  220.     FUSE_ACCESS        = 34,
  221.     FUSE_CREATE        = 35,
  222.     FUSE_INTERRUPT     = 36,
  223.     FUSE_BMAP          = 37,
  224.     FUSE_DESTROY       = 38,
  225.     FUSE_IOCTL         = 39,
  226.     FUSE_POLL          = 40,
  227.  
  228.     /* CUSE specific operations */
  229.     CUSE_INIT          = 4096,
  230. };
  231.  
  232. enum fuse_notify_code {
  233.     FUSE_NOTIFY_POLL   = 1,
  234.     FUSE_NOTIFY_INVAL_INODE = 2,
  235.     FUSE_NOTIFY_INVAL_ENTRY = 3,
  236.     FUSE_NOTIFY_CODE_MAX,
  237. };
  238.  
  239. /* The read buffer is required to be at least 8k, but may be much larger */
  240. #define FUSE_MIN_READ_BUFFER 8192
  241.  
  242. #define FUSE_COMPAT_ENTRY_OUT_SIZE 120
  243.  
  244. struct fuse_entry_out {
  245.     __u64    nodeid;        /* Inode ID */
  246.     __u64    generation;    /* Inode generation: nodeid:gen must
  247.                    be unique for the fs's lifetime */
  248.     __u64    entry_valid;    /* Cache timeout for the name */
  249.     __u64    attr_valid;    /* Cache timeout for the attributes */
  250.     __u32    entry_valid_nsec;
  251.     __u32    attr_valid_nsec;
  252.     struct fuse_attr attr;
  253. };
  254.  
  255. struct fuse_forget_in {
  256.     __u64    nlookup;
  257. };
  258.  
  259. struct fuse_getattr_in {
  260.     __u32    getattr_flags;
  261.     __u32    dummy;
  262.     __u64    fh;
  263. };
  264.  
  265. #define FUSE_COMPAT_ATTR_OUT_SIZE 96
  266.  
  267. struct fuse_attr_out {
  268.     __u64    attr_valid;    /* Cache timeout for the attributes */
  269.     __u32    attr_valid_nsec;
  270.     __u32    dummy;
  271.     struct fuse_attr attr;
  272. };
  273.  
  274. #define FUSE_COMPAT_MKNOD_IN_SIZE 8
  275.  
  276. struct fuse_mknod_in {
  277.     __u32    mode;
  278.     __u32    rdev;
  279.     __u32    umask;
  280.     __u32    padding;
  281. };
  282.  
  283. struct fuse_mkdir_in {
  284.     __u32    mode;
  285.     __u32    umask;
  286. };
  287.  
  288. struct fuse_rename_in {
  289.     __u64    newdir;
  290. };
  291.  
  292. struct fuse_link_in {
  293.     __u64    oldnodeid;
  294. };
  295.  
  296. struct fuse_setattr_in {
  297.     __u32    valid;
  298.     __u32    padding;
  299.     __u64    fh;
  300.     __u64    size;
  301.     __u64    lock_owner;
  302.     __u64    atime;
  303.     __u64    mtime;
  304.     __u64    unused2;
  305.     __u32    atimensec;
  306.     __u32    mtimensec;
  307.     __u32    unused3;
  308.     __u32    mode;
  309.     __u32    unused4;
  310.     __u32    uid;
  311.     __u32    gid;
  312.     __u32    unused5;
  313. };
  314.  
  315. struct fuse_open_in {
  316.     __u32    flags;
  317.     __u32    unused;
  318. };
  319.  
  320. struct fuse_create_in {
  321.     __u32    flags;
  322.     __u32    mode;
  323.     __u32    umask;
  324.     __u32    padding;
  325. };
  326.  
  327. struct fuse_open_out {
  328.     __u64    fh;
  329.     __u32    open_flags;
  330.     __u32    padding;
  331. };
  332.  
  333. struct fuse_release_in {
  334.     __u64    fh;
  335.     __u32    flags;
  336.     __u32    release_flags;
  337.     __u64    lock_owner;
  338. };
  339.  
  340. struct fuse_flush_in {
  341.     __u64    fh;
  342.     __u32    unused;
  343.     __u32    padding;
  344.     __u64    lock_owner;
  345. };
  346.  
  347. struct fuse_read_in {
  348.     __u64    fh;
  349.     __u64    offset;
  350.     __u32    size;
  351.     __u32    read_flags;
  352.     __u64    lock_owner;
  353.     __u32    flags;
  354.     __u32    padding;
  355. };
  356.  
  357. #define FUSE_COMPAT_WRITE_IN_SIZE 24
  358.  
  359. struct fuse_write_in {
  360.     __u64    fh;
  361.     __u64    offset;
  362.     __u32    size;
  363.     __u32    write_flags;
  364.     __u64    lock_owner;
  365.     __u32    flags;
  366.     __u32    padding;
  367. };
  368.  
  369. struct fuse_write_out {
  370.     __u32    size;
  371.     __u32    padding;
  372. };
  373.  
  374. #define FUSE_COMPAT_STATFS_SIZE 48
  375.  
  376. struct fuse_statfs_out {
  377.     struct fuse_kstatfs st;
  378. };
  379.  
  380. struct fuse_fsync_in {
  381.     __u64    fh;
  382.     __u32    fsync_flags;
  383.     __u32    padding;
  384. };
  385.  
  386. struct fuse_setxattr_in {
  387.     __u32    size;
  388.     __u32    flags;
  389. };
  390.  
  391. struct fuse_getxattr_in {
  392.     __u32    size;
  393.     __u32    padding;
  394. };
  395.  
  396. struct fuse_getxattr_out {
  397.     __u32    size;
  398.     __u32    padding;
  399. };
  400.  
  401. struct fuse_lk_in {
  402.     __u64    fh;
  403.     __u64    owner;
  404.     struct fuse_file_lock lk;
  405.     __u32    lk_flags;
  406.     __u32    padding;
  407. };
  408.  
  409. struct fuse_lk_out {
  410.     struct fuse_file_lock lk;
  411. };
  412.  
  413. struct fuse_access_in {
  414.     __u32    mask;
  415.     __u32    padding;
  416. };
  417.  
  418. struct fuse_init_in {
  419.     __u32    major;
  420.     __u32    minor;
  421.     __u32    max_readahead;
  422.     __u32    flags;
  423. };
  424.  
  425. struct fuse_init_out {
  426.     __u32    major;
  427.     __u32    minor;
  428.     __u32    max_readahead;
  429.     __u32    flags;
  430.     __u32    unused;
  431.     __u32    max_write;
  432. };
  433.  
  434. #define CUSE_INIT_INFO_MAX 4096
  435.  
  436. struct cuse_init_in {
  437.     __u32    major;
  438.     __u32    minor;
  439.     __u32    unused;
  440.     __u32    flags;
  441. };
  442.  
  443. struct cuse_init_out {
  444.     __u32    major;
  445.     __u32    minor;
  446.     __u32    unused;
  447.     __u32    flags;
  448.     __u32    max_read;
  449.     __u32    max_write;
  450.     __u32    dev_major;        /* chardev major */
  451.     __u32    dev_minor;        /* chardev minor */
  452.     __u32    spare[10];
  453. };
  454.  
  455. struct fuse_interrupt_in {
  456.     __u64    unique;
  457. };
  458.  
  459. struct fuse_bmap_in {
  460.     __u64    block;
  461.     __u32    blocksize;
  462.     __u32    padding;
  463. };
  464.  
  465. struct fuse_bmap_out {
  466.     __u64    block;
  467. };
  468.  
  469. struct fuse_ioctl_in {
  470.     __u64    fh;
  471.     __u32    flags;
  472.     __u32    cmd;
  473.     __u64    arg;
  474.     __u32    in_size;
  475.     __u32    out_size;
  476. };
  477.  
  478. struct fuse_ioctl_out {
  479.     __s32    result;
  480.     __u32    flags;
  481.     __u32    in_iovs;
  482.     __u32    out_iovs;
  483. };
  484.  
  485. struct fuse_poll_in {
  486.     __u64    fh;
  487.     __u64    kh;
  488.     __u32    flags;
  489.     __u32   padding;
  490. };
  491.  
  492. struct fuse_poll_out {
  493.     __u32    revents;
  494.     __u32    padding;
  495. };
  496.  
  497. struct fuse_notify_poll_wakeup_out {
  498.     __u64    kh;
  499. };
  500.  
  501. struct fuse_in_header {
  502.     __u32    len;
  503.     __u32    opcode;
  504.     __u64    unique;
  505.     __u64    nodeid;
  506.     __u32    uid;
  507.     __u32    gid;
  508.     __u32    pid;
  509.     __u32    padding;
  510. };
  511.  
  512. struct fuse_out_header {
  513.     __u32    len;
  514.     __s32    error;
  515.     __u64    unique;
  516. };
  517.  
  518. struct fuse_dirent {
  519.     __u64    ino;
  520.     __u64    off;
  521.     __u32    namelen;
  522.     __u32    type;
  523.     char name[0];
  524. };
  525.  
  526. #define FUSE_NAME_OFFSET offsetof(struct fuse_dirent, name)
  527. #define FUSE_DIRENT_ALIGN(x) (((x) + sizeof(__u64) - 1) & ~(sizeof(__u64) - 1))
  528. #define FUSE_DIRENT_SIZE(d) \
  529.     FUSE_DIRENT_ALIGN(FUSE_NAME_OFFSET + (d)->namelen)
  530.  
  531. struct fuse_notify_inval_inode_out {
  532.     __u64    ino;
  533.     __s64    off;
  534.     __s64    len;
  535. };
  536.  
  537. struct fuse_notify_inval_entry_out {
  538.     __u64    parent;
  539.     __u32    namelen;
  540.     __u32    padding;
  541. };
  542.  
  543. #endif /* _LINUX_FUSE_H */
  544.